home *** CD-ROM | disk | FTP | other *** search
/ Champak 138 / Volume 138 Aug 19 2011 - Damaged.iso / Games / trick_or_suite.swf / scripts / DefineButton2_170 / BUTTONCONDACTION on(press).as
Text File  |  2011-08-19  |  81KB  |  1,784 lines

  1. on(press){
  2.    var ┬º\x01┬º = 795;
  3.    loop0:
  4.    while(true)
  5.    {
  6.       if(eval("\x01") == 795)
  7.       {
  8.          set("\x01",eval("\x01") + 61);
  9.          ┬º┬ºpush(true);
  10.          continue;
  11.       }
  12.       if(eval("\x01") == 27)
  13.       {
  14.          set("\x01",eval("\x01") + 579);
  15.          continue;
  16.       }
  17.       if(eval("\x01") == 913)
  18.       {
  19.          set("\x01",eval("\x01") - 696);
  20.          break;
  21.       }
  22.       if(eval("\x01") == 606)
  23.       {
  24.          set("\x01",eval("\x01") - 115);
  25.          ┬º┬ºpush(true);
  26.          continue;
  27.       }
  28.       if(eval("\x01") == 707)
  29.       {
  30.          set("\x01",eval("\x01") + 167);
  31.          ┬º┬ºpush(true);
  32.          continue;
  33.       }
  34.       if(eval("\x01") == 491)
  35.       {
  36.          set("\x01",eval("\x01") + 280);
  37.          if(┬º┬ºpop())
  38.          {
  39.             set("\x01",eval("\x01") - 622);
  40.          }
  41.          continue;
  42.       }
  43.       if(eval("\x01") == 226)
  44.       {
  45.          set("\x01",eval("\x01") + 380);
  46.          continue;
  47.       }
  48.       if(eval("\x01") == 516)
  49.       {
  50.          set("\x01",eval("\x01") + 191);
  51.          continue;
  52.       }
  53.       if(eval("\x01") == 109)
  54.       {
  55.          set("\x01",eval("\x01") + 465);
  56.          continue;
  57.       }
  58.       if(eval("\x01") == 973)
  59.       {
  60.          set("\x01",eval("\x01") - 399);
  61.          continue;
  62.       }
  63.       if(eval("\x01") == 200)
  64.       {
  65.          set("\x01",eval("\x01") + 752);
  66.          ┬º┬ºpush(┬º┬ºpop() or new ┬º┬ºpop()[new ┬º┬ºpop()[┬º┬ºpop()]()]());
  67.          break;
  68.       }
  69.       if(eval("\x01") == 952)
  70.       {
  71.          set("\x01",eval("\x01") - 421);
  72.          continue;
  73.       }
  74.       if(eval("\x01") == 911)
  75.       {
  76.          set("\x01",eval("\x01") - 711);
  77.          if(┬º┬ºpop())
  78.          {
  79.             set("\x01",eval("\x01") + 752);
  80.          }
  81.          continue;
  82.       }
  83.       if(eval("\x01") == 890)
  84.       {
  85.          set("\x01",eval("\x01") - 610);
  86.          ┬º┬ºpush(true);
  87.          continue;
  88.       }
  89.       if(eval("\x01") == 99)
  90.       {
  91.          set("\x01",eval("\x01") + 812);
  92.          ┬º┬ºpush(true);
  93.          continue;
  94.       }
  95.       if(eval("\x01") == 722)
  96.       {
  97.          set("\x01",eval("\x01") - 415);
  98.          continue;
  99.       }
  100.       if(eval("\x01") == 298)
  101.       {
  102.          set("\x01",eval("\x01") + 233);
  103.          continue;
  104.       }
  105.       if(eval("\x01") == 244)
  106.       {
  107.          set("\x01",eval("\x01") + 115);
  108.          eval("[#^^∩┐╜")["∩┐╜o"][┬º┬ºconstant(3)]("q7∩┐╜X9");
  109.          eval("[#^^∩┐╜")[┬º┬ºconstant(6)](┬º┬ºconstant(5),┬º┬ºconstant(4));
  110.          gotoAndStop("Start");
  111.          play();
  112.          break;
  113.       }
  114.       if(eval("\x01") == 884)
  115.       {
  116.          set("\x01",eval("\x01") - 791);
  117.          break;
  118.       }
  119.       if(eval("\x01") == 306)
  120.       {
  121.          set("\x01",eval("\x01") + 584);
  122.          continue;
  123.       }
  124.       if(eval("\x01") == 354)
  125.       {
  126.          set("\x01",eval("\x01") - 255);
  127.          continue;
  128.       }
  129.       if(eval("\x01") == 590)
  130.       {
  131.          set("\x01",eval("\x01") - 346);
  132.          continue;
  133.       }
  134.       if(eval("\x01") == 874)
  135.       {
  136.          set("\x01",eval("\x01") - 136);
  137.          if(┬º┬ºpop())
  138.          {
  139.             set("\x01",eval("\x01") - 512);
  140.          }
  141.          continue;
  142.       }
  143.       if(eval("\x01") == 915)
  144.       {
  145.          set("\x01",eval("\x01") - 730);
  146.          break;
  147.       }
  148.       if(eval("\x01") == 299)
  149.       {
  150.          set("\x01",eval("\x01") + 8);
  151.          continue;
  152.       }
  153.       if(eval("\x01") == 272)
  154.       {
  155.          set("\x01",eval("\x01") + 435);
  156.          continue;
  157.       }
  158.       if(eval("\x01") == 824)
  159.       {
  160.          set("\x01",eval("\x01") + 66);
  161.          continue;
  162.       }
  163.       if(eval("\x01") == 696)
  164.       {
  165.          set("\x01",eval("\x01") + 217);
  166.          if(┬º┬ºpop())
  167.          {
  168.             set("\x01",eval("\x01") - 696);
  169.          }
  170.          continue;
  171.       }
  172.       if(eval("\x01") == 149)
  173.       {
  174.          set("\x01",eval("\x01") + 581);
  175.          continue;
  176.       }
  177.       if(eval("\x01") == 395)
  178.       {
  179.          set("\x01",eval("\x01") + 489);
  180.          if(┬º┬ºpop())
  181.          {
  182.             set("\x01",eval("\x01") - 791);
  183.          }
  184.          continue;
  185.       }
  186.       if(eval("\x01") == 118)
  187.       {
  188.          set("\x01",eval("\x01") + 154);
  189.          break;
  190.       }
  191.       if(eval("\x01") == 307)
  192.       {
  193.          set("\x01",eval("\x01") + 389);
  194.          ┬º┬ºpush(true);
  195.          continue;
  196.       }
  197.       if(eval("\x01") == 738)
  198.       {
  199.          set("\x01",eval("\x01") - 512);
  200.          loop1:
  201.          while(true)
  202.          {
  203.             set(┬º┬ºpop(),┬º┬ºpop());
  204.             while(true)
  205.             {
  206.                if(eval("\x01") == 543)
  207.                {
  208.                   set("\x01",eval("\x01") - 186);
  209.                   ┬º┬ºpush(true);
  210.                   continue;
  211.                }
  212.                if(eval("\x01") == 846)
  213.                {
  214.                   set("\x01",eval("\x01") - 499);
  215.                   continue;
  216.                }
  217.                if(eval("\x01") == 357)
  218.                {
  219.                   set("\x01",eval("\x01") + 574);
  220.                   if(┬º┬ºpop())
  221.                   {
  222.                      set("\x01",eval("\x01") - 602);
  223.                   }
  224.                   continue;
  225.                }
  226.                if(eval("\x01") == 766)
  227.                {
  228.                   set("\x01",eval("\x01") - 113);
  229.                   ┬º┬ºpush(true);
  230.                   continue;
  231.                }
  232.                if(eval("\x01") == 653)
  233.                {
  234.                   set("\x01",eval("\x01") - 650);
  235.                   if(┬º┬ºpop())
  236.                   {
  237.                      set("\x01",eval("\x01") + 245);
  238.                   }
  239.                   continue;
  240.                }
  241.                if(eval("\x01") == 248)
  242.                {
  243.                   set("\x01",eval("\x01") + 99);
  244.                   continue;
  245.                }
  246.                if(eval("\x01") == 907)
  247.                {
  248.                   break loop1;
  249.                }
  250.                if(eval("\x01") == 723)
  251.                {
  252.                   set("\x01",eval("\x01") - 152);
  253.                   ┬º┬ºpush(true);
  254.                   continue;
  255.                }
  256.                if(eval("\x01") == 92)
  257.                {
  258.                   set("\x01",eval("\x01") + 674);
  259.                   continue;
  260.                }
  261.                if(eval("\x01") == 931)
  262.                {
  263.                   set("\x01",eval("\x01") - 602);
  264.                   addr205:
  265.                   if(┬º┬ºpop() == ┬º┬ºpop())
  266.                   {
  267.                      set("\x01",eval("\x01") - 470);
  268.                      addr53:
  269.                      if(eval("\x01") == 671)
  270.                      {
  271.                         set("\x01",eval("\x01") + 87);
  272.                         ┬º┬ºgoto(addr53);
  273.                         ┬º┬ºpush(true);
  274.                      }
  275.                      if(eval("\x01") == 422)
  276.                      {
  277.                         set("\x01",eval("\x01") - 129);
  278.                         if(!┬º┬ºpop())
  279.                         {
  280.                            addr95:
  281.                            ┬º┬ºgoto(addr53);
  282.                         }
  283.                         set("\x01",eval("\x01") + 473);
  284.                         ┬º┬ºgoto(addr95);
  285.                      }
  286.                      if(eval("\x01") == 769)
  287.                      {
  288.                         set("\x01",eval("\x01") - 550);
  289.                         if(!┬º┬ºpop())
  290.                         {
  291.                            addr116:
  292.                            ┬º┬ºgoto(addr53);
  293.                         }
  294.                         set("\x01",eval("\x01") - 78);
  295.                         ┬º┬ºgoto(addr116);
  296.                      }
  297.                      if(eval("\x01") == 998)
  298.                      {
  299.                         set("\x01",eval("\x01") - 962);
  300.                         ┬º┬ºgoto(addr53);
  301.                      }
  302.                      if(eval("\x01") == 504)
  303.                      {
  304.                         set("\x01",eval("\x01") - 370);
  305.                         if(!┬º┬ºpop())
  306.                         {
  307.                            addr153:
  308.                            ┬º┬ºgoto(addr53);
  309.                         }
  310.                         set("\x01",eval("\x01") + 25);
  311.                         ┬º┬ºgoto(addr153);
  312.                      }
  313.                      if(eval("\x01") == 744)
  314.                      {
  315.                         set("\x01",eval("\x01") - 690);
  316.                         ┬º┬ºgoto(addr53);
  317.                      }
  318.                      if(eval("\x01") == 133)
  319.                      {
  320.                         set("\x01",eval("\x01") + 636);
  321.                         ┬º┬ºgoto(addr53);
  322.                         ┬º┬ºpush(true);
  323.                      }
  324.                      if(eval("\x01") == 758)
  325.                      {
  326.                         set("\x01",eval("\x01") - 177);
  327.                         if(!┬º┬ºpop())
  328.                         {
  329.                            addr201:
  330.                            ┬º┬ºgoto(addr53);
  331.                         }
  332.                         set("\x01",eval("\x01") + 417);
  333.                         ┬º┬ºgoto(addr201);
  334.                      }
  335.                      ┬º┬ºgoto(addr205);
  336.                      ┬º┬ºpush(eval("\x01"));
  337.                      ┬º┬ºpush(506);
  338.                   }
  339.                   if(eval("\x01") != 32)
  340.                   {
  341.                      if(eval("\x01") == 54)
  342.                      {
  343.                         set("\x01",eval("\x01") + 782);
  344.                         ┬º┬ºgoto(addr53);
  345.                         ┬º┬ºpush(true);
  346.                      }
  347.                      if(eval("\x01") == 812)
  348.                      {
  349.                         set("\x01",eval("\x01") - 169);
  350.                         ┬º┬ºgoto(addr53);
  351.                      }
  352.                      if(eval("\x01") != 293)
  353.                      {
  354.                         if(eval("\x01") == 433)
  355.                         {
  356.                            set("\x01",eval("\x01") + 250);
  357.                            ┬º┬ºgoto(addr53);
  358.                         }
  359.                         if(eval("\x01") == 291)
  360.                         {
  361.                            set("\x01",eval("\x01") - 188);
  362.                            if(!┬º┬ºpop())
  363.                            {
  364.                               addr312:
  365.                               ┬º┬ºgoto(addr53);
  366.                            }
  367.                            set("\x01",eval("\x01") + 506);
  368.                            ┬º┬ºgoto(addr312);
  369.                         }
  370.                         if(eval("\x01") == 708)
  371.                         {
  372.                            set("\x01",eval("\x01") + 78);
  373.                            if(!┬º┬ºpop())
  374.                            {
  375.                               addr333:
  376.                               ┬º┬ºgoto(addr53);
  377.                            }
  378.                            set("\x01",eval("\x01") - 42);
  379.                            ┬º┬ºgoto(addr333);
  380.                         }
  381.                         if(eval("\x01") != 120)
  382.                         {
  383.                            if(eval("\x01") != 409)
  384.                            {
  385.                               if(eval("\x01") == 547)
  386.                               {
  387.                                  set("\x01",eval("\x01") + 131);
  388.                                  if(!┬º┬ºpop())
  389.                                  {
  390.                                     addr380:
  391.                                     ┬º┬ºgoto(addr53);
  392.                                  }
  393.                                  set("\x01",eval("\x01") - 675);
  394.                                  ┬º┬ºgoto(addr380);
  395.                               }
  396.                               if(eval("\x01") != 581)
  397.                               {
  398.                                  if(eval("\x01") == 750)
  399.                                  {
  400.                                     set("\x01",eval("\x01") - 246);
  401.                                     ┬º┬ºgoto(addr53);
  402.                                     ┬º┬ºpush(true);
  403.                                  }
  404.                                  if(eval("\x01") == 263)
  405.                                  {
  406.                                     set("\x01",eval("\x01") + 445);
  407.                                     ┬º┬ºgoto(addr53);
  408.                                     ┬º┬ºpush(true);
  409.                                  }
  410.                                  if(eval("\x01") == 147)
  411.                                  {
  412.                                     set("\x01",eval("\x01") + 407);
  413.                                     ┬º┬ºgoto(addr53);
  414.                                  }
  415.                                  if(eval("\x01") != 25)
  416.                                  {
  417.                                     if(eval("\x01") == 36)
  418.                                     {
  419.                                        set("\x01",eval("\x01") + 255);
  420.                                        ┬º┬ºgoto(addr53);
  421.                                        ┬º┬ºpush(true);
  422.                                     }
  423.                                     if(eval("\x01") == 75)
  424.                                     {
  425.                                        set("\x01",eval("\x01") + 334);
  426.                                        if(!┬º┬ºpop())
  427.                                        {
  428.                                           addr484:
  429.                                           ┬º┬ºgoto(addr53);
  430.                                        }
  431.                                        set("\x01",eval("\x01") + 130);
  432.                                        ┬º┬ºgoto(addr484);
  433.                                     }
  434.                                     if(eval("\x01") != 103)
  435.                                     {
  436.                                        if(eval("\x01") == 939)
  437.                                        {
  438.                                           set("\x01",eval("\x01") - 517);
  439.                                           ┬º┬ºgoto(addr53);
  440.                                           ┬º┬ºpush(true);
  441.                                        }
  442.                                        if(eval("\x01") == 719)
  443.                                        {
  444.                                           set("\x01",eval("\x01") + 31);
  445.                                           ┬º┬ºgoto(addr53);
  446.                                        }
  447.                                        if(eval("\x01") != 134)
  448.                                        {
  449.                                           if(eval("\x01") != 786)
  450.                                           {
  451.                                              if(eval("\x01") == 159)
  452.                                              {
  453.                                                 set("\x01",eval("\x01") + 484);
  454.                                                 ┬º┬ºgoto(addr53);
  455.                                              }
  456.                                              if(eval("\x01") == 609)
  457.                                              {
  458.                                                 set("\x01",eval("\x01") + 74);
  459.                                                 ┬º┬ºgoto(addr53);
  460.                                              }
  461.                                              if(eval("\x01") != 219)
  462.                                              {
  463.                                                 if(eval("\x01") == 683)
  464.                                                 {
  465.                                                    set("\x01",eval("\x01") - 608);
  466.                                                    ┬º┬ºgoto(addr53);
  467.                                                    ┬º┬ºpush(true);
  468.                                                 }
  469.                                                 if(eval("\x01") == 16)
  470.                                                 {
  471.                                                    set("\x01",eval("\x01") + 923);
  472.                                                    ┬º┬ºgoto(addr53);
  473.                                                 }
  474.                                                 if(eval("\x01") == 239)
  475.                                                 {
  476.                                                    set("\x01",eval("\x01") - 214);
  477.                                                    ┬º┬ºgoto(addr53);
  478.                                                 }
  479.                                                 if(eval("\x01") == 3)
  480.                                                 {
  481.                                                    set("\x01",eval("\x01") + 22);
  482.                                                    ┬º┬ºgoto(addr53);
  483.                                                 }
  484.                                                 if(eval("\x01") == 539)
  485.                                                 {
  486.                                                    set("\x01",eval("\x01") - 406);
  487.                                                    ┬º┬ºgoto(addr53);
  488.                                                 }
  489.                                                 if(eval("\x01") == 680)
  490.                                                 {
  491.                                                    set("\x01",eval("\x01") - 547);
  492.                                                    ┬º┬ºgoto(addr53);
  493.                                                 }
  494.                                                 if(eval("\x01") != 678)
  495.                                                 {
  496.                                                    if(eval("\x01") == 643)
  497.                                                    {
  498.                                                       set("\x01",eval("\x01") - 96);
  499.                                                       ┬º┬ºgoto(addr53);
  500.                                                       ┬º┬ºpush(true);
  501.                                                    }
  502.                                                    if(eval("\x01") == 132)
  503.                                                    {
  504.                                                       set("\x01",eval("\x01") - 78);
  505.                                                       ┬º┬ºgoto(addr53);
  506.                                                    }
  507.                                                    if(eval("\x01") == 836)
  508.                                                    {
  509.                                                       set("\x01",eval("\x01") - 716);
  510.                                                       if(!┬º┬ºpop())
  511.                                                       {
  512.                                                          addr734:
  513.                                                          ┬º┬ºgoto(addr53);
  514.                                                       }
  515.                                                       set("\x01",eval("\x01") + 203);
  516.                                                       ┬º┬ºgoto(addr734);
  517.                                                    }
  518.                                                    if(eval("\x01") == 20)
  519.                                                    {
  520.                                                       set("\x01",eval("\x01") + 730);
  521.                                                       ┬º┬ºgoto(addr53);
  522.                                                    }
  523.                                                    if(eval("\x01") != 945)
  524.                                                    {
  525.                                                       if(eval("\x01") == 501)
  526.                                                       {
  527.                                                          set("\x01",eval("\x01") - 469);
  528.                                                          if(!┬º┬ºpop())
  529.                                                          {
  530.                                                             addr781:
  531.                                                             ┬º┬ºgoto(addr53);
  532.                                                          }
  533.                                                          set("\x01",eval("\x01") - 12);
  534.                                                          ┬º┬ºgoto(addr781);
  535.                                                       }
  536.                                                       if(eval("\x01") == 8)
  537.                                                       {
  538.                                                          set("\x01",eval("\x01") + 255);
  539.                                                          ┬º┬ºgoto(addr53);
  540.                                                       }
  541.                                                       if(eval("\x01") == 323)
  542.                                                       {
  543.                                                          set("\x01",eval("\x01") + 616);
  544.                                                          ┬º┬ºgoto(addr53);
  545.                                                       }
  546.                                                       if(eval("\x01") == 141)
  547.                                                       {
  548.                                                          set("\x01",eval("\x01") + 122);
  549.                                                          ┬º┬ºgoto(addr53);
  550.                                                       }
  551.                                                       if(eval("\x01") == 554)
  552.                                                       {
  553.                                                          set("\x01",eval("\x01") - 53);
  554.                                                          ┬º┬ºgoto(addr53);
  555.                                                          ┬º┬ºpush(true);
  556.                                                       }
  557.                                                       if(eval("\x01") == 766)
  558.                                                       {
  559.                                                          set("\x01",eval("\x01") - 212);
  560.                                                          ┬º┬ºgoto(addr53);
  561.                                                       }
  562.                                                       break loop0;
  563.                                                    }
  564.                                                    set("\x01",eval("\x01") - 945);
  565.                                                    break loop0;
  566.                                                 }
  567.                                                 set("\x01",eval("\x01") - 675);
  568.                                                 String(┬º┬ºpop()) implements ;
  569.                                                 break loop0;
  570.                                              }
  571.                                              set("\x01",eval("\x01") - 78);
  572.                                              break loop0;
  573.                                           }
  574.                                           set("\x01",eval("\x01") - 42);
  575.                                           break loop0;
  576.                                        }
  577.                                        set("\x01",eval("\x01") + 25);
  578.                                        ┬º┬ºpush(┬º┬ºpop() | ┬º┬ºpop());
  579.                                        break loop0;
  580.                                     }
  581.                                     set("\x01",eval("\x01") + 506);
  582.                                     break loop0;
  583.                                  }
  584.                                  set("\x01",eval("\x01") + 920);
  585.                                  gotoAndStop(1);
  586.                                  break loop0;
  587.                               }
  588.                               set("\x01",eval("\x01") + 417);
  589.                               ┬º┬ºpush(length(┬º┬ºpop() === ┬º┬ºpop()[┬º┬ºpop()]));
  590.                               break loop0;
  591.                            }
  592.                            set("\x01",eval("\x01") + 130);
  593.                            ┬º┬ºpush(┬º┬ºpop() instanceof ┬º┬ºpop() << ┬º┬ºpop());
  594.                            break loop0;
  595.                         }
  596.                         set("\x01",eval("\x01") + 203);
  597.                         ┬º┬ºpush(┬º┬ºpop() eq ┬º┬ºpop());
  598.                         break loop0;
  599.                      }
  600.                      set("\x01",eval("\x01") + 473);
  601.                      toggleHighQuality();
  602.                      ┬º┬ºpush(┬º┬ºpop() eq ┬º┬ºpop());
  603.                      break loop0;
  604.                   }
  605.                   set("\x01",eval("\x01") - 12);
  606.                   break loop0;
  607.                }
  608.                if(eval("\x01") == 779)
  609.                {
  610.                   set("\x01",eval("\x01") - 323);
  611.                   addr2181:
  612.                   if(eval("\x01") == 189)
  613.                   {
  614.                      set("\x01",eval("\x01") + 480);
  615.                      addr1999:
  616.                      if(eval("\x01") == 112)
  617.                      {
  618.                         set("\x01",eval("\x01") + 384);
  619.                         ┬º┬ºgoto(addr1999);
  620.                         ┬º┬ºpush(true);
  621.                      }
  622.                      if(eval("\x01") == 163)
  623.                      {
  624.                         set("\x01",eval("\x01") - 103);
  625.                         if(!┬º┬ºpop())
  626.                         {
  627.                            addr2038:
  628.                            ┬º┬ºgoto(addr1999);
  629.                         }
  630.                         set("\x01",eval("\x01") - 37);
  631.                         ┬º┬ºgoto(addr2038);
  632.                      }
  633.                      if(eval("\x01") == 932)
  634.                      {
  635.                         set("\x01",eval("\x01") - 480);
  636.                         if(!┬º┬ºpop())
  637.                         {
  638.                            addr2059:
  639.                            ┬º┬ºgoto(addr1999);
  640.                         }
  641.                         set("\x01",eval("\x01") + 429);
  642.                         ┬º┬ºgoto(addr2059);
  643.                      }
  644.                      if(eval("\x01") == 881)
  645.                      {
  646.                         set("\x01",eval("\x01") + 105);
  647.                         ┬º┬ºgoto(addr1999);
  648.                      }
  649.                      if(eval("\x01") != 426)
  650.                      {
  651.                         if(eval("\x01") != 60)
  652.                         {
  653.                            if(eval("\x01") != 452)
  654.                            {
  655.                               if(eval("\x01") == 986)
  656.                               {
  657.                                  set("\x01",eval("\x01") - 823);
  658.                                  ┬º┬ºgoto(addr1999);
  659.                                  ┬º┬ºpush(true);
  660.                               }
  661.                               if(eval("\x01") != 809)
  662.                               {
  663.                                  if(eval("\x01") == 453)
  664.                                  {
  665.                                     set("\x01",eval("\x01") + 113);
  666.                                     ┬º┬ºgoto(addr1999);
  667.                                     ┬º┬ºpush(true);
  668.                                  }
  669.                                  if(eval("\x01") == 50)
  670.                                  {
  671.                                     set("\x01",eval("\x01") + 144);
  672.                                     ┬º┬ºgoto(addr1999);
  673.                                  }
  674.                                  if(eval("\x01") == 938)
  675.                                  {
  676.                                     set("\x01",eval("\x01") - 507);
  677.                                     ┬º┬ºgoto(addr1999);
  678.                                  }
  679.                                  ┬º┬ºgoto(addr2181);
  680.                               }
  681.                               set("\x01",eval("\x01") + 31);
  682.                               break loop0;
  683.                            }
  684.                            set("\x01",eval("\x01") + 429);
  685.                            break loop0;
  686.                         }
  687.                         set("\x01",eval("\x01") - 37);
  688.                         break loop0;
  689.                      }
  690.                      set("\x01",eval("\x01") + 549);
  691.                      ┬º┬ºpush(new ┬º\┬º\┬ºpop() | \┬º\┬ºpop()┬º());
  692.                      break loop0;
  693.                   }
  694.                   if(eval("\x01") == 781)
  695.                   {
  696.                      set("\x01",eval("\x01") - 44);
  697.                      ┬º┬ºgoto(addr1999);
  698.                      ┬º┬ºpush(true);
  699.                   }
  700.                   if(eval("\x01") == 5)
  701.                   {
  702.                      set("\x01",eval("\x01") + 981);
  703.                      ┬º┬ºgoto(addr1999);
  704.                   }
  705.                   if(eval("\x01") == 566)
  706.                   {
  707.                      set("\x01",eval("\x01") - 213);
  708.                      if(!┬º┬ºpop())
  709.                      {
  710.                         addr2243:
  711.                         ┬º┬ºgoto(addr1999);
  712.                      }
  713.                      set("\x01",eval("\x01") + 521);
  714.                      ┬º┬ºgoto(addr2243);
  715.                   }
  716.                   if(eval("\x01") == 761)
  717.                   {
  718.                      set("\x01",eval("\x01") + 171);
  719.                      ┬º┬ºgoto(addr1999);
  720.                      ┬º┬ºpush(true);
  721.                   }
  722.                   if(eval("\x01") == 207)
  723.                   {
  724.                      set("\x01",eval("\x01") + 554);
  725.                      ┬º┬ºgoto(addr1999);
  726.                   }
  727.                   if(eval("\x01") != 353)
  728.                   {
  729.                      if(eval("\x01") == 840)
  730.                      {
  731.                         set("\x01",eval("\x01") - 409);
  732.                         ┬º┬ºgoto(addr1999);
  733.                      }
  734.                      if(eval("\x01") != 156)
  735.                      {
  736.                         if(eval("\x01") == 69)
  737.                         {
  738.                            set("\x01",eval("\x01") + 384);
  739.                            ┬º┬ºgoto(addr1999);
  740.                         }
  741.                         if(eval("\x01") == 23)
  742.                         {
  743.                            set("\x01",eval("\x01") + 285);
  744.                            ┬º┬ºgoto(addr1999);
  745.                         }
  746.                         if(eval("\x01") == 768)
  747.                         {
  748.                            set("\x01",eval("\x01") - 315);
  749.                            ┬º┬ºgoto(addr1999);
  750.                         }
  751.                         if(eval("\x01") == 874)
  752.                         {
  753.                            set("\x01",eval("\x01") - 680);
  754.                            ┬º┬ºgoto(addr1999);
  755.                         }
  756.                         if(eval("\x01") != 851)
  757.                         {
  758.                            if(eval("\x01") == 483)
  759.                            {
  760.                               set("\x01",eval("\x01") + 298);
  761.                               ┬º┬ºgoto(addr1999);
  762.                            }
  763.                            if(eval("\x01") == 813)
  764.                            {
  765.                               set("\x01",eval("\x01") - 52);
  766.                               ┬º┬ºgoto(addr1999);
  767.                            }
  768.                            if(eval("\x01") == 729)
  769.                            {
  770.                               set("\x01",eval("\x01") - 421);
  771.                               ┬º┬ºgoto(addr1999);
  772.                            }
  773.                            if(eval("\x01") == 496)
  774.                            {
  775.                               set("\x01",eval("\x01") + 355);
  776.                               if(!┬º┬ºpop())
  777.                               {
  778.                                  addr2437:
  779.                                  ┬º┬ºgoto(addr1999);
  780.                               }
  781.                               set("\x01",eval("\x01") - 83);
  782.                               ┬º┬ºgoto(addr2437);
  783.                            }
  784.                            if(eval("\x01") == 430)
  785.                            {
  786.                               set("\x01",eval("\x01") - 274);
  787.                               if(!┬º┬ºpop())
  788.                               {
  789.                                  addr2458:
  790.                                  ┬º┬ºgoto(addr1999);
  791.                               }
  792.                               set("\x01",eval("\x01") + 657);
  793.                               ┬º┬ºgoto(addr2458);
  794.                            }
  795.                            if(eval("\x01") == 28)
  796.                            {
  797.                               set("\x01",eval("\x01") + 613);
  798.                               ┬º┬ºgoto(addr1999);
  799.                            }
  800.                            if(eval("\x01") != 308)
  801.                            {
  802.                               if(eval("\x01") == 641)
  803.                               {
  804.                                  set("\x01",eval("\x01") - 211);
  805.                                  ┬º┬ºgoto(addr1999);
  806.                                  ┬º┬ºpush(true);
  807.                               }
  808.                               if(eval("\x01") == 194)
  809.                               {
  810.                                  set("\x01",eval("\x01") + 383);
  811.                                  ┬º┬ºgoto(addr1999);
  812.                                  ┬º┬ºpush(true);
  813.                               }
  814.                               if(eval("\x01") == 577)
  815.                               {
  816.                                  set("\x01",eval("\x01") + 232);
  817.                                  if(!┬º┬ºpop())
  818.                                  {
  819.                                     addr2534:
  820.                                     ┬º┬ºgoto(addr1999);
  821.                                  }
  822.                                  set("\x01",eval("\x01") + 31);
  823.                                  ┬º┬ºgoto(addr2534);
  824.                               }
  825.                               if(eval("\x01") != 783)
  826.                               {
  827.                                  if(eval("\x01") == 431)
  828.                                  {
  829.                                     set("\x01",eval("\x01") + 70);
  830.                                     ┬º┬ºgoto(addr1999);
  831.                                     ┬º┬ºpush(true);
  832.                                  }
  833.                                  if(eval("\x01") == 501)
  834.                                  {
  835.                                     set("\x01",eval("\x01") - 421);
  836.                                     if(!┬º┬ºpop())
  837.                                     {
  838.                                        addr2582:
  839.                                        ┬º┬ºgoto(addr1999);
  840.                                     }
  841.                                     set("\x01",eval("\x01") + 403);
  842.                                     ┬º┬ºgoto(addr2582);
  843.                                  }
  844.                                  if(eval("\x01") != 80)
  845.                                  {
  846.                                     if(eval("\x01") == 40)
  847.                                     {
  848.                                        set("\x01",eval("\x01") + 741);
  849.                                        ┬º┬ºgoto(addr1999);
  850.                                     }
  851.                                     if(eval("\x01") == 737)
  852.                                     {
  853.                                        set("\x01",eval("\x01") - 311);
  854.                                        if(!┬º┬ºpop())
  855.                                        {
  856.                                           addr2630:
  857.                                           ┬º┬ºgoto(addr1999);
  858.                                        }
  859.                                        set("\x01",eval("\x01") + 549);
  860.                                        ┬º┬ºgoto(addr2630);
  861.                                     }
  862.                                     if(eval("\x01") == 611)
  863.                                     {
  864.                                        set("\x01",eval("\x01") + 30);
  865.                                        ┬º┬ºgoto(addr1999);
  866.                                     }
  867.                                     if(eval("\x01") == 975)
  868.                                     {
  869.                                        set("\x01",eval("\x01") - 306);
  870.                                        ┬º┬ºgoto(addr1999);
  871.                                     }
  872.                                     if(eval("\x01") == 642)
  873.                                     {
  874.                                        set("\x01",eval("\x01") - 365);
  875.                                        if(!┬º┬ºpop())
  876.                                        {
  877.                                           addr2678:
  878.                                           ┬º┬ºgoto(addr1999);
  879.                                        }
  880.                                        set("\x01",eval("\x01") - 249);
  881.                                        ┬º┬ºgoto(addr2678);
  882.                                     }
  883.                                     if(eval("\x01") == 669)
  884.                                     {
  885.                                        set("\x01",eval("\x01") - 27);
  886.                                        ┬º┬ºgoto(addr1999);
  887.                                        ┬º┬ºpush(true);
  888.                                     }
  889.                                     if(eval("\x01") == 277)
  890.                                     {
  891.                                        set("\x01",eval("\x01") - 249);
  892.                                        break loop0;
  893.                                     }
  894.                                     break loop0;
  895.                                  }
  896.                                  set("\x01",eval("\x01") + 403);
  897.                                  break loop0;
  898.                               }
  899.                               set("\x01",eval("\x01") - 783);
  900.                               break loop0;
  901.                            }
  902.                            set("\x01",eval("\x01") + 475);
  903.                            gotoAndStop(1);
  904.                            break loop0;
  905.                         }
  906.                         set("\x01",eval("\x01") - 83);
  907.                         break loop0;
  908.                      }
  909.                      set("\x01",eval("\x01") + 657);
  910.                      addr1614:
  911.                      if(┬º┬ºpop())
  912.                      {
  913.                         set("\x01",eval("\x01") - 190);
  914.                         if(!┬º┬ºpop())
  915.                         {
  916.                            addr1580:
  917.                            if(eval("\x01") == 706)
  918.                            {
  919.                               set("\x01",eval("\x01") + 80);
  920.                               ┬º┬ºgoto(addr1580);
  921.                               ┬º┬ºpush(true);
  922.                            }
  923.                            if(eval("\x01") != 784)
  924.                            {
  925.                               ┬º┬ºgoto(addr1614);
  926.                               ┬º┬ºpush(eval("\x01") == 786);
  927.                            }
  928.                            set("\x01",eval("\x01") - 63);
  929.                            prevFrame();
  930.                            break loop0;
  931.                            addr1630:
  932.                         }
  933.                         set("\x01",eval("\x01") - 252);
  934.                         ┬º┬ºgoto(addr1630);
  935.                      }
  936.                      if(eval("\x01") == 976)
  937.                      {
  938.                         set("\x01",eval("\x01") - 562);
  939.                         ┬º┬ºgoto(addr1580);
  940.                      }
  941.                      if(eval("\x01") == 433)
  942.                      {
  943.                         set("\x01",eval("\x01") - 19);
  944.                         ┬º┬ºgoto(addr1580);
  945.                      }
  946.                      if(eval("\x01") == 851)
  947.                      {
  948.                         set("\x01",eval("\x01") - 549);
  949.                         if(!┬º┬ºpop())
  950.                         {
  951.                            addr1678:
  952.                            ┬º┬ºgoto(addr1580);
  953.                         }
  954.                         set("\x01",eval("\x01") - 171);
  955.                         ┬º┬ºgoto(addr1678);
  956.                      }
  957.                      if(eval("\x01") != 81)
  958.                      {
  959.                         if(eval("\x01") == 200)
  960.                         {
  961.                            set("\x01",eval("\x01") + 125);
  962.                            ┬º┬ºgoto(addr1580);
  963.                         }
  964.                         if(eval("\x01") == 162)
  965.                         {
  966.                            set("\x01",eval("\x01") + 722);
  967.                            ┬º┬ºgoto(addr1580);
  968.                            ┬º┬ºpush(true);
  969.                         }
  970.                         if(eval("\x01") == 725)
  971.                         {
  972.                            set("\x01",eval("\x01") - 563);
  973.                            ┬º┬ºgoto(addr1580);
  974.                         }
  975.                         if(eval("\x01") == 818)
  976.                         {
  977.                            set("\x01",eval("\x01") - 737);
  978.                            if(!┬º┬ºpop())
  979.                            {
  980.                               addr1754:
  981.                               ┬º┬ºgoto(addr1580);
  982.                            }
  983.                            set("\x01",eval("\x01") + 895);
  984.                            ┬º┬ºgoto(addr1754);
  985.                         }
  986.                         if(eval("\x01") == 721)
  987.                         {
  988.                            set("\x01",eval("\x01") - 559);
  989.                            ┬º┬ºgoto(addr1580);
  990.                         }
  991.                         if(eval("\x01") == 820)
  992.                         {
  993.                            set("\x01",eval("\x01") - 36);
  994.                            if(!┬º┬ºpop())
  995.                            {
  996.                               addr1788:
  997.                               ┬º┬ºgoto(addr1580);
  998.                            }
  999.                            set("\x01",eval("\x01") - 63);
  1000.                            ┬º┬ºgoto(addr1788);
  1001.                         }
  1002.                         if(eval("\x01") == 344)
  1003.                         {
  1004.                            set("\x01",eval("\x01") - 19);
  1005.                            ┬º┬ºgoto(addr1580);
  1006.                         }
  1007.                         addr1811:
  1008.                         if(eval("\x01") == 414)
  1009.                         {
  1010.                            set("\x01",eval("\x01") + 437);
  1011.                            ┬º┬ºgoto(addr1580);
  1012.                            ┬º┬ºpush(true);
  1013.                         }
  1014.                         if(eval("\x01") == 325)
  1015.                         {
  1016.                            set("\x01",eval("\x01") + 493);
  1017.                            ┬º┬ºgoto(addr1580);
  1018.                            ┬º┬ºpush(true);
  1019.                         }
  1020.                         if(eval("\x01") == 131)
  1021.                         {
  1022.                            set("\x01",eval("\x01") + 833);
  1023.                            ┬º┬ºgoto(addr1580);
  1024.                         }
  1025.                         if(eval("\x01") != 596)
  1026.                         {
  1027.                            if(eval("\x01") != 302)
  1028.                            {
  1029.                               if(eval("\x01") == 884)
  1030.                               {
  1031.                                  set("\x01",eval("\x01") - 192);
  1032.                                  if(!┬º┬ºpop())
  1033.                                  {
  1034.                                     addr1895:
  1035.                                     ┬º┬ºgoto(addr1580);
  1036.                                  }
  1037.                                  set("\x01",eval("\x01") - 226);
  1038.                                  ┬º┬ºgoto(addr1895);
  1039.                               }
  1040.                               if(eval("\x01") == 593)
  1041.                               {
  1042.                                  set("\x01",eval("\x01") + 371);
  1043.                                  ┬º┬ºgoto(addr1580);
  1044.                               }
  1045.                               if(eval("\x01") == 964)
  1046.                               {
  1047.                                  set("\x01",eval("\x01") - 144);
  1048.                                  ┬º┬ºgoto(addr1580);
  1049.                                  ┬º┬ºpush(true);
  1050.                               }
  1051.                               if(eval("\x01") != 692)
  1052.                               {
  1053.                                  if(eval("\x01") == 466)
  1054.                                  {
  1055.                                     set("\x01",eval("\x01") - 59);
  1056.                                     ┬º┬ºgoto(addr1580);
  1057.                                  }
  1058.                                  if(eval("\x01") != 407)
  1059.                                  {
  1060.                                     if(eval("\x01") == 83)
  1061.                                     {
  1062.                                        set("\x01",eval("\x01") + 324);
  1063.                                        ┬º┬ºgoto(addr1580);
  1064.                                     }
  1065.                                     if(eval("\x01") == 112)
  1066.                                     {
  1067.                                        set("\x01",eval("\x01") - 112);
  1068.                                        break loop0;
  1069.                                     }
  1070.                                     break loop0;
  1071.                                  }
  1072.                                  set("\x01",eval("\x01") - 295);
  1073.                                  gotoAndStop(1);
  1074.                                  break loop0;
  1075.                               }
  1076.                               set("\x01",eval("\x01") - 226);
  1077.                               addr1352:
  1078.                               if(!┬º┬ºpop())
  1079.                               {
  1080.                                  set("\x01",eval("\x01") - 833);
  1081.                                  if(!┬º┬ºpop())
  1082.                                  {
  1083.                                     addr859:
  1084.                                     if(eval("\x01") == 812)
  1085.                                     {
  1086.                                        set("\x01",eval("\x01") - 23);
  1087.                                        ┬º┬ºgoto(addr859);
  1088.                                        ┬º┬ºpush(true);
  1089.                                     }
  1090.                                     if(eval("\x01") != 880)
  1091.                                     {
  1092.                                        if(eval("\x01") != 652)
  1093.                                        {
  1094.                                           if(eval("\x01") == 792)
  1095.                                           {
  1096.                                              set("\x01",eval("\x01") - 501);
  1097.                                              ┬º┬ºgoto(addr859);
  1098.                                           }
  1099.                                           if(eval("\x01") == 448)
  1100.                                           {
  1101.                                              set("\x01",eval("\x01") + 53);
  1102.                                              ┬º┬ºgoto(addr859);
  1103.                                           }
  1104.                                           if(eval("\x01") == 569)
  1105.                                           {
  1106.                                              set("\x01",eval("\x01") - 165);
  1107.                                              ┬º┬ºgoto(addr859);
  1108.                                           }
  1109.                                           if(eval("\x01") != 423)
  1110.                                           {
  1111.                                              if(eval("\x01") != 373)
  1112.                                              {
  1113.                                                 if(eval("\x01") == 847)
  1114.                                                 {
  1115.                                                    set("\x01",eval("\x01") - 636);
  1116.                                                    ┬º┬ºgoto(addr859);
  1117.                                                 }
  1118.                                                 if(eval("\x01") == 382)
  1119.                                                 {
  1120.                                                    set("\x01",eval("\x01") - 171);
  1121.                                                    ┬º┬ºgoto(addr859);
  1122.                                                 }
  1123.                                                 if(eval("\x01") == 672)
  1124.                                                 {
  1125.                                                    set("\x01",eval("\x01") + 306);
  1126.                                                    ┬º┬ºgoto(addr859);
  1127.                                                 }
  1128.                                                 if(eval("\x01") == 365)
  1129.                                                 {
  1130.                                                    set("\x01",eval("\x01") + 39);
  1131.                                                    ┬º┬ºgoto(addr859);
  1132.                                                 }
  1133.                                                 if(eval("\x01") == 772)
  1134.                                                 {
  1135.                                                    set("\x01",eval("\x01") - 120);
  1136.                                                    if(!┬º┬ºpop())
  1137.                                                    {
  1138.                                                       addr1045:
  1139.                                                       ┬º┬ºgoto(addr859);
  1140.                                                    }
  1141.                                                    set("\x01",eval("\x01") + 195);
  1142.                                                    ┬º┬ºgoto(addr1045);
  1143.                                                 }
  1144.                                                 if(eval("\x01") == 212)
  1145.                                                 {
  1146.                                                    set("\x01",eval("\x01") + 334);
  1147.                                                    ┬º┬ºgoto(addr859);
  1148.                                                 }
  1149.                                                 if(eval("\x01") == 722)
  1150.                                                 {
  1151.                                                    set("\x01",eval("\x01") - 264);
  1152.                                                    ┬º┬ºgoto(addr859);
  1153.                                                 }
  1154.                                                 if(eval("\x01") == 609)
  1155.                                                 {
  1156.                                                    set("\x01",eval("\x01") - 441);
  1157.                                                    ┬º┬ºgoto(addr859);
  1158.                                                    ┬º┬ºpush(true);
  1159.                                                 }
  1160.                                                 if(eval("\x01") == 37)
  1161.                                                 {
  1162.                                                    set("\x01",eval("\x01") + 336);
  1163.                                                    if(!┬º┬ºpop())
  1164.                                                    {
  1165.                                                       addr1108:
  1166.                                                       ┬º┬ºgoto(addr859);
  1167.                                                    }
  1168.                                                    set("\x01",eval("\x01") - 8);
  1169.                                                    ┬º┬ºgoto(addr1108);
  1170.                                                 }
  1171.                                                 if(eval("\x01") == 766)
  1172.                                                 {
  1173.                                                    set("\x01",eval("\x01") - 570);
  1174.                                                    if(!┬º┬ºpop())
  1175.                                                    {
  1176.                                                       addr1129:
  1177.                                                       ┬º┬ºgoto(addr859);
  1178.                                                    }
  1179.                                                    set("\x01",eval("\x01") + 119);
  1180.                                                    ┬º┬ºgoto(addr1129);
  1181.                                                 }
  1182.                                                 if(eval("\x01") == 776)
  1183.                                                 {
  1184.                                                    set("\x01",eval("\x01") - 318);
  1185.                                                    ┬º┬ºgoto(addr859);
  1186.                                                 }
  1187.                                                 if(eval("\x01") == 789)
  1188.                                                 {
  1189.                                                    set("\x01",eval("\x01") - 203);
  1190.                                                    if(!┬º┬ºpop())
  1191.                                                    {
  1192.                                                       addr1163:
  1193.                                                       ┬º┬ºgoto(addr859);
  1194.                                                    }
  1195.                                                    set("\x01",eval("\x01") - 279);
  1196.                                                    ┬º┬ºgoto(addr1163);
  1197.                                                 }
  1198.                                                 addr1172:
  1199.                                                 if(eval("\x01") != 989)
  1200.                                                 {
  1201.                                                    addr1180:
  1202.                                                    if(eval("\x01") == 291)
  1203.                                                    {
  1204.                                                       set("\x01",eval("\x01") + 475);
  1205.                                                       ┬º┬ºgoto(addr859);
  1206.                                                       ┬º┬ºpush(true);
  1207.                                                    }
  1208.                                                    if(eval("\x01") == 152)
  1209.                                                    {
  1210.                                                       set("\x01",eval("\x01") + 620);
  1211.                                                       ┬º┬ºgoto(addr859);
  1212.                                                       ┬º┬ºpush(true);
  1213.                                                    }
  1214.                                                    if(eval("\x01") == 422)
  1215.                                                    {
  1216.                                                       set("\x01",eval("\x01") - 291);
  1217.                                                       if(!┬º┬ºpop())
  1218.                                                       {
  1219.                                                          addr1228:
  1220.                                                          ┬º┬ºgoto(addr859);
  1221.                                                       }
  1222.                                                       set("\x01",eval("\x01") + 533);
  1223.                                                       ┬º┬ºgoto(addr1228);
  1224.                                                    }
  1225.                                                    if(eval("\x01") == 315)
  1226.                                                    {
  1227.                                                       set("\x01",eval("\x01") + 186);
  1228.                                                       ┬º┬ºgoto(addr859);
  1229.                                                    }
  1230.                                                    if(eval("\x01") == 501)
  1231.                                                    {
  1232.                                                       set("\x01",eval("\x01") - 79);
  1233.                                                       ┬º┬ºgoto(addr859);
  1234.                                                       ┬º┬ºpush(true);
  1235.                                                    }
  1236.                                                    if(eval("\x01") == 819)
  1237.                                                    {
  1238.                                                       set("\x01",eval("\x01") - 528);
  1239.                                                       ┬º┬ºgoto(addr859);
  1240.                                                    }
  1241.                                                    if(eval("\x01") == 211)
  1242.                                                    {
  1243.                                                       set("\x01",eval("\x01") - 174);
  1244.                                                       ┬º┬ºgoto(addr859);
  1245.                                                       ┬º┬ºpush(true);
  1246.                                                    }
  1247.                                                    if(eval("\x01") == 168)
  1248.                                                    {
  1249.                                                       set("\x01",eval("\x01") + 712);
  1250.                                                       if(!┬º┬ºpop())
  1251.                                                       {
  1252.                                                          addr1304:
  1253.                                                          ┬º┬ºgoto(addr859);
  1254.                                                       }
  1255.                                                       set("\x01",eval("\x01") - 213);
  1256.                                                       ┬º┬ºgoto(addr1304);
  1257.                                                    }
  1258.                                                    if(eval("\x01") == 577)
  1259.                                                    {
  1260.                                                       set("\x01",eval("\x01") - 154);
  1261.                                                       if(!┬º┬ºpop())
  1262.                                                       {
  1263.                                                          addr1325:
  1264.                                                          ┬º┬ºgoto(addr859);
  1265.                                                       }
  1266.                                                       set("\x01",eval("\x01") + 353);
  1267.                                                       ┬º┬ºgoto(addr1325);
  1268.                                                    }
  1269.                                                    if(eval("\x01") == 366)
  1270.                                                    {
  1271.                                                       set("\x01",eval("\x01") + 623);
  1272.                                                       if(!┬º┬ºpop())
  1273.                                                       {
  1274.                                                          addr1346:
  1275.                                                          ┬º┬ºgoto(addr859);
  1276.                                                       }
  1277.                                                       set("\x01",eval("\x01") - 197);
  1278.                                                       ┬º┬ºgoto(addr1346);
  1279.                                                    }
  1280.                                                    ┬º┬ºgoto(addr1352);
  1281.                                                    ┬º┬ºpush(eval("\x01") != 845);
  1282.                                                 }
  1283.                                                 set("\x01",eval("\x01") - 197);
  1284.                                                 break loop0;
  1285.                                              }
  1286.                                              set("\x01",eval("\x01") - 8);
  1287.                                              break loop0;
  1288.                                           }
  1289.                                           set("\x01",eval("\x01") + 353);
  1290.                                           break loop0;
  1291.                                        }
  1292.                                        set("\x01",eval("\x01") + 195);
  1293.                                        break loop0;
  1294.                                     }
  1295.                                     set("\x01",eval("\x01") - 213);
  1296.                                     break loop0;
  1297.                                     addr1367:
  1298.                                  }
  1299.                                  set("\x01",eval("\x01") + 779);
  1300.                                  ┬º┬ºgoto(addr1367);
  1301.                               }
  1302.                               if(eval("\x01") == 483)
  1303.                               {
  1304.                                  set("\x01",eval("\x01") + 126);
  1305.                                  ┬º┬ºgoto(addr859);
  1306.                               }
  1307.                               if(eval("\x01") == 978)
  1308.                               {
  1309.                                  set("\x01",eval("\x01") - 401);
  1310.                                  ┬º┬ºgoto(addr859);
  1311.                                  ┬º┬ºpush(true);
  1312.                               }
  1313.                               if(eval("\x01") == 458)
  1314.                               {
  1315.                                  set("\x01",eval("\x01") + 387);
  1316.                                  ┬º┬ºgoto(addr859);
  1317.                                  ┬º┬ºpush(true);
  1318.                               }
  1319.                               if(eval("\x01") == 307)
  1320.                               {
  1321.                                  set("\x01",eval("\x01") + 671);
  1322.                                  ┬º┬ºgoto(addr859);
  1323.                               }
  1324.                               if(eval("\x01") != 131)
  1325.                               {
  1326.                                  if(eval("\x01") == 791)
  1327.                                  {
  1328.                                     set("\x01",eval("\x01") - 182);
  1329.                                     ┬º┬ºgoto(addr859);
  1330.                                  }
  1331.                                  if(eval("\x01") != 12)
  1332.                                  {
  1333.                                     if(eval("\x01") == 664)
  1334.                                     {
  1335.                                        set("\x01",eval("\x01") - 512);
  1336.                                        ┬º┬ºgoto(addr859);
  1337.                                     }
  1338.                                     if(eval("\x01") != 196)
  1339.                                     {
  1340.                                        if(eval("\x01") == 546)
  1341.                                        {
  1342.                                           set("\x01",eval("\x01") - 180);
  1343.                                           ┬º┬ºgoto(addr859);
  1344.                                           ┬º┬ºpush(true);
  1345.                                        }
  1346.                                        if(eval("\x01") == 758)
  1347.                                        {
  1348.                                           set("\x01",eval("\x01") - 606);
  1349.                                           ┬º┬ºgoto(addr859);
  1350.                                        }
  1351.                                        if(eval("\x01") != 586)
  1352.                                        {
  1353.                                           if(eval("\x01") != 404)
  1354.                                           {
  1355.                                              if(eval("\x01") != 955)
  1356.                                              {
  1357.                                                 if(eval("\x01") == 667)
  1358.                                                 {
  1359.                                                    set("\x01",eval("\x01") - 121);
  1360.                                                    ┬º┬ºgoto(addr859);
  1361.                                                 }
  1362.                                                 break loop0;
  1363.                                              }
  1364.                                              set("\x01",eval("\x01") - 955);
  1365.                                              break loop0;
  1366.                                           }
  1367.                                           set("\x01",eval("\x01") + 551);
  1368.                                           gotoAndStop(1);
  1369.                                           break loop0;
  1370.                                        }
  1371.                                        set("\x01",eval("\x01") - 279);
  1372.                                        break loop0;
  1373.                                     }
  1374.                                     set("\x01",eval("\x01") + 119);
  1375.                                     break loop0;
  1376.                                  }
  1377.                                  set("\x01",eval("\x01") + 779);
  1378.                                  stopAllSounds();
  1379.                                  tellTarget("∩┐╜")
  1380.                                  {
  1381.                                     break loop0;
  1382.                                  }
  1383.                               }
  1384.                               set("\x01",eval("\x01") + 533);
  1385.                               break loop0;
  1386.                            }
  1387.                            set("\x01",eval("\x01") - 171);
  1388.                            prevFrame();
  1389.                            addr3163:
  1390.                            set(┬º┬ºpop(),eval(┬º┬ºpop()) + 446);
  1391.                            addr3083:
  1392.                            ┬º┬ºpush(true);
  1393.                            if(eval("\x01") == 675)
  1394.                            {
  1395.                               set("\x01",eval("\x01") + 320);
  1396.                               ┬º┬ºgoto(addr3083);
  1397.                               ┬º┬ºpush(true);
  1398.                            }
  1399.                            if(eval("\x01") != 837)
  1400.                            {
  1401.                               if(eval("\x01") == 86)
  1402.                               {
  1403.                                  set("\x01",eval("\x01") + 380);
  1404.                                  ┬º┬ºgoto(addr3083);
  1405.                               }
  1406.                               if(eval("\x01") == 422)
  1407.                               {
  1408.                                  set("\x01",eval("\x01") - 11);
  1409.                                  ┬º┬ºgoto(addr3083);
  1410.                                  ┬º┬ºpush(true);
  1411.                               }
  1412.                               if(eval("\x01") == 881)
  1413.                               {
  1414.                                  set("\x01",eval("\x01") - 329);
  1415.                                  ┬º┬ºgoto(addr3083);
  1416.                               }
  1417.                               if(eval("\x01") == 552)
  1418.                               {
  1419.                                  ┬º┬ºgoto(addr3163);
  1420.                                  ┬º┬ºpush("\x01");
  1421.                                  ┬º┬ºpush("\x01");
  1422.                               }
  1423.                               if(eval("\x01") == 995)
  1424.                               {
  1425.                                  set("\x01",eval("\x01") - 158);
  1426.                                  if(!┬º┬ºpop())
  1427.                                  {
  1428.                                     addr3189:
  1429.                                     ┬º┬ºgoto(addr3163);
  1430.                                  }
  1431.                                  set("\x01",eval("\x01") - 407);
  1432.                                  ┬º┬ºgoto(addr3189);
  1433.                               }
  1434.                               if(eval("\x01") == 316)
  1435.                               {
  1436.                                  set("\x01",eval("\x01") + 267);
  1437.                                  ┬º┬ºgoto(addr3163);
  1438.                               }
  1439.                               if(eval("\x01") == 576)
  1440.                               {
  1441.                                  set("\x01",eval("\x01") + 115);
  1442.                                  ┬º┬ºgoto(addr3163);
  1443.                               }
  1444.                               if(eval("\x01") != 489)
  1445.                               {
  1446.                                  if(eval("\x01") != 683)
  1447.                                  {
  1448.                                     if(eval("\x01") == 897)
  1449.                                     {
  1450.                                        set("\x01",eval("\x01") - 345);
  1451.                                        ┬º┬ºgoto(addr3163);
  1452.                                     }
  1453.                                     if(eval("\x01") == 411)
  1454.                                     {
  1455.                                        set("\x01",eval("\x01") + 272);
  1456.                                        if(!┬º┬ºpop())
  1457.                                        {
  1458.                                           addr3275:
  1459.                                           ┬º┬ºgoto(addr3163);
  1460.                                        }
  1461.                                        set("\x01",eval("\x01") - 107);
  1462.                                        ┬º┬ºgoto(addr3275);
  1463.                                     }
  1464.                                     if(eval("\x01") != 874)
  1465.                                     {
  1466.                                        if(eval("\x01") == 436)
  1467.                                        {
  1468.                                           set("\x01",eval("\x01") + 255);
  1469.                                           ┬º┬ºgoto(addr3163);
  1470.                                        }
  1471.                                        if(eval("\x01") != 466)
  1472.                                        {
  1473.                                           if(eval("\x01") == 691)
  1474.                                           {
  1475.                                              set("\x01",eval("\x01") + 137);
  1476.                                              ┬º┬ºgoto(addr3163);
  1477.                                              ┬º┬ºpush(true);
  1478.                                           }
  1479.                                           if(eval("\x01") == 998)
  1480.                                           {
  1481.                                              set("\x01",eval("\x01") - 357);
  1482.                                              if(!┬º┬ºpop())
  1483.                                              {
  1484.                                                 addr3353:
  1485.                                                 ┬º┬ºgoto(addr3163);
  1486.                                              }
  1487.                                              set("\x01",eval("\x01") + 301);
  1488.                                              ┬º┬ºgoto(addr3353);
  1489.                                           }
  1490.                                           if(eval("\x01") != 641)
  1491.                                           {
  1492.                                              if(eval("\x01") == 472)
  1493.                                              {
  1494.                                                 set("\x01",eval("\x01") + 111);
  1495.                                                 ┬º┬ºgoto(addr3163);
  1496.                                              }
  1497.                                              if(eval("\x01") == 488)
  1498.                                              {
  1499.                                                 set("\x01",eval("\x01") - 66);
  1500.                                                 ┬º┬ºgoto(addr3163);
  1501.                                              }
  1502.                                              if(eval("\x01") != 261)
  1503.                                              {
  1504.                                                 if(eval("\x01") == 828)
  1505.                                                 {
  1506.                                                    set("\x01",eval("\x01") - 339);
  1507.                                                    if(!┬º┬ºpop())
  1508.                                                    {
  1509.                                                       addr3428:
  1510.                                                       ┬º┬ºgoto(addr3163);
  1511.                                                    }
  1512.                                                    set("\x01",eval("\x01") - 173);
  1513.                                                    ┬º┬ºgoto(addr3428);
  1514.                                                 }
  1515.                                                 if(eval("\x01") == 430)
  1516.                                                 {
  1517.                                                    set("\x01",eval("\x01") - 8);
  1518.                                                    ┬º┬ºgoto(addr3163);
  1519.                                                 }
  1520.                                                 if(eval("\x01") == 942)
  1521.                                                 {
  1522.                                                    set("\x01",eval("\x01") - 856);
  1523.                                                    ┬º┬ºgoto(addr3163);
  1524.                                                 }
  1525.                                                 if(eval("\x01") == 260)
  1526.                                                 {
  1527.                                                    set("\x01",eval("\x01") - 174);
  1528.                                                    ┬º┬ºgoto(addr3163);
  1529.                                                 }
  1530.                                                 if(eval("\x01") == 583)
  1531.                                                 {
  1532.                                                    set("\x01",eval("\x01") - 249);
  1533.                                                    ┬º┬ºgoto(addr3163);
  1534.                                                    ┬º┬ºpush(true);
  1535.                                                 }
  1536.                                                 if(eval("\x01") == 334)
  1537.                                                 {
  1538.                                                    set("\x01",eval("\x01") + 540);
  1539.                                                    if(!┬º┬ºpop())
  1540.                                                    {
  1541.                                                       addr3506:
  1542.                                                       ┬º┬ºgoto(addr3163);
  1543.                                                    }
  1544.                                                    set("\x01",eval("\x01") + 23);
  1545.                                                    ┬º┬ºgoto(addr3506);
  1546.                                                 }
  1547.                                                 break loop0;
  1548.                                              }
  1549.                                              set("\x01",eval("\x01") - 261);
  1550.                                              break loop0;
  1551.                                           }
  1552.                                           set("\x01",eval("\x01") + 301);
  1553.                                           break loop0;
  1554.                                        }
  1555.                                        set("\x01",eval("\x01") - 205);
  1556.                                        stop();
  1557.                                        var ┬º5∩┐╜\x01┬º = ["Ω₧æ∩┐╜","─░}0RKA∩┐╜",":∩┐╜("];
  1558.                                        var ┬º┬ºconstant(4) = ┬º┬ºconstant(5);
  1559.                                        var ┬º┬ºconstant(6) = eval(┬º┬ºconstant(4));
  1560.                                        var ┬º┬ºconstant(7) = null;
  1561.                                        eval(┬º┬ºconstant(8))[┬º┬ºconstant(9)][┬º┬ºconstant(10)] = ┬º┬ºconstant(11);
  1562.                                        break loop0;
  1563.                                     }
  1564.                                     set("\x01",eval("\x01") + 23);
  1565.                                     break loop0;
  1566.                                  }
  1567.                                  set("\x01",eval("\x01") - 107);
  1568.                                  break loop0;
  1569.                               }
  1570.                               set("\x01",eval("\x01") - 173);
  1571.                               ┬º┬ºgoto(addr1180);
  1572.                            }
  1573.                            set("\x01",eval("\x01") - 407);
  1574.                            break loop0;
  1575.                         }
  1576.                         set("\x01",eval("\x01") - 252);
  1577.                         break loop0;
  1578.                      }
  1579.                      set("\x01",eval("\x01") + 895);
  1580.                      prevFrame();
  1581.                      break loop0;
  1582.                   }
  1583.                   set("\x01",eval("\x01") + 521);
  1584.                   break loop0;
  1585.                }
  1586.                if(eval("\x01") == 911)
  1587.                {
  1588.                   set("\x01",eval("\x01") - 132);
  1589.                   if(┬º┬ºpop())
  1590.                   {
  1591.                      set("\x01",eval("\x01") - 323);
  1592.                   }
  1593.                   continue;
  1594.                }
  1595.                if(eval("\x01") == 544)
  1596.                {
  1597.                   set("\x01",eval("\x01") + 363);
  1598.                   continue;
  1599.                }
  1600.                if(eval("\x01") == 3)
  1601.                {
  1602.                   set("\x01",eval("\x01") + 245);
  1603.                   break loop0;
  1604.                }
  1605.                if(eval("\x01") == 456)
  1606.                {
  1607.                   set("\x01",eval("\x01") + 267);
  1608.                   continue;
  1609.                }
  1610.                if(eval("\x01") == 347)
  1611.                {
  1612.                   set("\x01",eval("\x01") + 564);
  1613.                   ┬º┬ºpush(true);
  1614.                   continue;
  1615.                }
  1616.                if(eval("\x01") == 329)
  1617.                {
  1618.                   set("\x01",eval("\x01") + 437);
  1619.                   continue;
  1620.                }
  1621.                if(eval("\x01") == 155)
  1622.                {
  1623.                   set("\x01",eval("\x01") + 568);
  1624.                   continue;
  1625.                }
  1626.                if(eval("\x01") == 571)
  1627.                {
  1628.                   set("\x01",eval("\x01") - 109);
  1629.                   if(┬º┬ºpop())
  1630.                   {
  1631.                      set("\x01",eval("\x01") - 84);
  1632.                   }
  1633.                   continue;
  1634.                }
  1635.                if(eval("\x01") == 848)
  1636.                {
  1637.                   set("\x01",eval("\x01") - 848);
  1638.                   break loop0;
  1639.                }
  1640.                if(eval("\x01") != 462)
  1641.                {
  1642.                   if(eval("\x01") != 378)
  1643.                   {
  1644.                      break loop0;
  1645.                   }
  1646.                   continue loop1;
  1647.                }
  1648.                set("\x01",eval("\x01") - 84);
  1649.                call(┬º┬ºpop());
  1650.                ┬º┬ºgoto(addr1811);
  1651.             }
  1652.          }
  1653.          set("\x01",eval("\x01") - 59);
  1654.          gotoAndStop(1);
  1655.          break;
  1656.       }
  1657.       if(eval("\x01") == 359)
  1658.       {
  1659.          set("\x01",eval("\x01") - 359);
  1660.          break;
  1661.       }
  1662.       if(eval("\x01") == 574)
  1663.       {
  1664.          set("\x01",eval("\x01") - 179);
  1665.          ┬º┬ºpush(true);
  1666.          continue;
  1667.       }
  1668.       if(eval("\x01") == 730)
  1669.       {
  1670.          set("\x01",eval("\x01") - 174);
  1671.          ┬º┬ºpush(true);
  1672.          continue;
  1673.       }
  1674.       if(eval("\x01") == 531)
  1675.       {
  1676.          set("\x01",eval("\x01") - 276);
  1677.          ┬º┬ºpush(true);
  1678.          continue;
  1679.       }
  1680.       if(eval("\x01") == 255)
  1681.       {
  1682.          set("\x01",eval("\x01") - 137);
  1683.          if(┬º┬ºpop())
  1684.          {
  1685.             set("\x01",eval("\x01") + 154);
  1686.          }
  1687.          continue;
  1688.       }
  1689.       if(eval("\x01") == 898)
  1690.       {
  1691.          set("\x01",eval("\x01") - 789);
  1692.          break;
  1693.       }
  1694.       if(eval("\x01") == 280)
  1695.       {
  1696.          set("\x01",eval("\x01") + 618);
  1697.          if(┬º┬ºpop())
  1698.          {
  1699.             set("\x01",eval("\x01") - 789);
  1700.          }
  1701.          continue;
  1702.       }
  1703.       if(eval("\x01") == 912)
  1704.       {
  1705.          set("\x01",eval("\x01") + 6);
  1706.          ┬º┬ºpush(true);
  1707.          continue;
  1708.       }
  1709.       if(eval("\x01") == 93)
  1710.       {
  1711.          set("\x01",eval("\x01") + 6);
  1712.          continue;
  1713.       }
  1714.       if(eval("\x01") == 217)
  1715.       {
  1716.          set("\x01",eval("\x01") + 373);
  1717.          continue;
  1718.       }
  1719.       if(eval("\x01") == 899)
  1720.       {
  1721.          set("\x01",eval("\x01") - 75);
  1722.          break;
  1723.       }
  1724.       if(eval("\x01") == 856)
  1725.       {
  1726.          set("\x01",eval("\x01") + 43);
  1727.          if(┬º┬ºpop())
  1728.          {
  1729.             set("\x01",eval("\x01") - 75);
  1730.          }
  1731.          continue;
  1732.       }
  1733.       if(eval("\x01") == 771)
  1734.       {
  1735.          set("\x01",eval("\x01") - 622);
  1736.          break;
  1737.       }
  1738.       if(eval("\x01") == 685)
  1739.       {
  1740.          set("\x01",eval("\x01") + 45);
  1741.          continue;
  1742.       }
  1743.       if(eval("\x01") == 556)
  1744.       {
  1745.          set("\x01",eval("\x01") + 359);
  1746.          if(┬º┬ºpop())
  1747.          {
  1748.             set("\x01",eval("\x01") - 730);
  1749.          }
  1750.          continue;
  1751.       }
  1752.       if(eval("\x01") == 185)
  1753.       {
  1754.          set("\x01",eval("\x01") + 727);
  1755.          continue;
  1756.       }
  1757.       if(eval("\x01") == 793)
  1758.       {
  1759.          set("\x01",eval("\x01") + 119);
  1760.          continue;
  1761.       }
  1762.       if(eval("\x01") == 918)
  1763.       {
  1764.          set("\x01",eval("\x01") - 452);
  1765.          if(┬º┬ºpop())
  1766.          {
  1767.             set("\x01",eval("\x01") - 167);
  1768.          }
  1769.          continue;
  1770.       }
  1771.       if(eval("\x01") != 466)
  1772.       {
  1773.          if(eval("\x01") != 452)
  1774.          {
  1775.             break;
  1776.          }
  1777.          set("\x01",eval("\x01") + 138);
  1778.          continue;
  1779.       }
  1780.       set("\x01",eval("\x01") - 167);
  1781.       ┬º┬ºgoto(addr1172);
  1782.    }
  1783. }
  1784.